/**
   
   @file Afficher_ecran.c
   @brief Description du code Afficher_ecran.c
   @code
   ClutterActor *stage;
   void AfficherEcran()
   {
    ClutterColor stage_color ={255,255,255,0xff};//Ecran blanc
    GtkWidget *clutter_widget = gtk_clutter_embed_new ();
    gtk_widget_show (clutter_widget);
    gtk_widget_set_size_request (clutter_widget,700, 700);

    //Recupere les donnees de la fenetre:
    stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (clutter_widget));
    clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);

    //On affiche la fenetre
    clutter_actor_show (stage);
   }
   @endcode


*/
/**

@file Barre_outils_animation.c
   @brief Details des fonctions de Barre_outils_animations.c
   @code
   //Creation de la barre d'outils
   void CreationBarreOutilsAnimation(Scenario * sc,Marqueur * mq)
   {
    Sc * S = malloc(sizeof(Sc));
    S->s = sc;
    S->m = mq;
    GtkWidget * pToolbar = NULL;
    //Declaration des objets qui vont contenir les boutons
    GtkToolItem * D_GD = NULL;
    GtkToolItem * D_HB = NULL;
    GtkToolItem * S_X = NULL;
    GtkToolItem * R_Z = NULL;
    GtkToolItem * Jouer = NULL;
    GtkToolItem * Pause = NULL;
    GtkToolItem * Stop = NULL;
  
    //Declaration de la fenetre et de la "boite" qui va contenir la barre d'outils
    GtkWidget *pWindow;
    GtkWidget *pVBox;

    //Creation de la fenetre
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Barre Outils Animation");
    gtk_window_set_default_size(GTK_WINDOW(pWindow),720,20);
    g_signal_connect(G_OBJECT(pWindow), "destroy",G_CALLBACK(gtk_main_quit), NULL);

    pVBox = gtk_box_new(TRUE,0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);

    //Creation de la barre d'outils
    pToolbar = gtk_toolbar_new();
    gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0);

    GtkWidget *button = gtk_button_new_with_label ("Deplacement_GD");
    GtkWidget *button2 = gtk_button_new_with_label ("Deplacement_HB");
    GtkWidget *button3 = gtk_button_new_with_label ("Scale_X");
    GtkWidget *button4 = gtk_button_new_with_label ("Rotation_Z");
    GtkWidget *button5 = gtk_button_new_with_label ("Jouer");
    GtkWidget *button6 = gtk_button_new_with_label ("Pause");
    GtkWidget *button7 = gtk_button_new_with_label ("Stop");

    gtk_widget_show (button);
    gtk_widget_show (button2);
    gtk_widget_show (button3);
    gtk_widget_show (button4);
    gtk_widget_show (button5);
    gtk_widget_show (button6);
    gtk_widget_show (button7);

    D_GD = gtk_tool_button_new(button,NULL);
    D_HB = gtk_tool_button_new(button2,NULL);
    S_X = gtk_tool_button_new(button3,NULL);
    R_Z = gtk_tool_button_new(button4,NULL);
    Jouer = gtk_tool_button_new(button5,NULL);
    Pause = gtk_tool_button_new(button6,NULL);
    Stop = gtk_tool_button_new(button7,NULL);

    //Insertion des boutons dans la barre d'outils
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),D_GD,0);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),D_HB,-1);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),S_X,-1);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),R_Z,-1);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),Jouer,-1);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),Pause,-1);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),Stop,-1);

    gtk_widget_show_all(pWindow);

    //Appels des fonctions de deplacement
    g_signal_connect (D_GD, "clicked",G_CALLBACK (on_boutton_deplacementGD),(Sc*)S);
    g_signal_connect (D_HB, "clicked",G_CALLBACK (on_boutton_deplacementHB),(Sc*)S);
    g_signal_connect (S_X, "clicked",G_CALLBACK (on_boutton_changement_dechelleX),(Sc*)S);
    g_signal_connect (R_Z, "clicked",G_CALLBACK (on_boutton_RotationZ),(Sc*)S);
    g_signal_connect (Jouer, "clicked",G_CALLBACK (DeroulerScenario),(Sc*)S);  
   }

   //Fonctions qui appelent les fonctions d'animation quand les boutons de la barre d'outils sont actives
   gboolean on_boutton_deplacementGD(GtkButton *bouton, gpointer user_data)
   {
    Sc * S=(Sc*)user_data;
    S->m->index_fonction=1;
    boite_saisie_animation(S->m,S->s); 
    return TRUE;
   }

   gboolean on_boutton_deplacementHB(GtkButton *bouton, gpointer user_data)
   {  
    Sc * S=(Sc*)user_data;
    S->m->index_fonction=2;
    boite_saisie_animation(S->m,S->s);
    return TRUE;
   }

   gboolean on_boutton_changement_dechelleX(GtkButton *bouton, gpointer user_data)
   { 
    Sc * S=(Sc*)user_data;
    S->m->index_fonction=3;
    boite_saisie_animation(S->m,S->s);
    return TRUE;
   }

   gboolean on_boutton_RotationZ(GtkButton *bouton, gpointer user_data)
   {
    Sc * S=(Sc*)user_data;
    S->m->index_fonction=4;
    boite_saisie_animation(S->m,S->s);
    return TRUE;
   }
   @endcode
*/

/**
@file Barre_outils_dessins.c
   @brief Description du code de Barre_outils_dessins.c
   @code
   //Creation de la barre d'outils
   void CreationBarreOutilsDessins(Carre c, Rectangle rec, Cercle cer, Plume p)
   {
    GtkWidget * pToolbar = NULL;
    //Declaration des objets qui vont contenir les boutons
    GtkToolItem * Carr = NULL;
    GtkToolItem * Rectangle = NULL;
    GtkToolItem * Cercle = NULL;
    GtkToolItem * Plume = NULL;

    //Declaration de la fenetre et de la "boite" qui va contenir la barre d'outils
    GtkWidget *pWindow;
    GtkWidget *pVBox;
  
    GtkWidget *button = gtk_button_new_with_label ("Carre");
    GtkWidget *button2 = gtk_button_new_with_label ("Rectangle");
    GtkWidget *button3 = gtk_button_new_with_label ("Cercle");
    GtkWidget *button4 = gtk_button_new_with_label ("Plume");

    InitCarre(&c); 
    InitRectangle(&rec);
    InitCercle(&cer);
    InitPlume(&p);
  
    //Creation de la fenetre
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "GtkToolbar");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);

    pVBox = gtk_box_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
  
    //Creation de la barre d'outils
    pToolbar = gtk_toolbar_new();
    gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0);
  
    gtk_widget_show (button);
    gtk_widget_show (button2);
    gtk_widget_show (button3);
    gtk_widget_show (button4);

    Carr = gtk_tool_button_new(button,NULL);
    Rectangle = gtk_tool_button_new(button2,NULL);
    Cercle = gtk_tool_button_new(button3,NULL);
    Plume = gtk_tool_button_new(button4,NULL);

    //Insertion des boutons dans la barre d'outils
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),Carr,0);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),Rectangle,-1);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),Cercle,-1);
    gtk_toolbar_insert(GTK_TOOLBAR(pToolbar),Plume,-1);

    gtk_widget_show_all(pWindow);

    g_signal_connect (Carr, "clicked",G_CALLBACK (on_boutton_dessiner_carre),(gpointer)&c);
    g_signal_connect (Rectangle, "clicked",G_CALLBACK (on_boutton_dessiner_rectangle),(gpointer)&rec);
    g_signal_connect (Cercle, "clicked",G_CALLBACK (on_boutton_dessiner_cercle),(gpointer)&cer);
    g_signal_connect (Plume, "clicked",G_CALLBACK (on_boutton_dessiner_plume),(gpointer)&p);
   }

   //Fonctions qui appelent les fonctions d'animation quand les boutons de la barre d'outils sont actifs
   gboolean on_boutton_dessiner_carre(GtkButton *button, gpointer user_data)
   {
    Carre * c=(Carre*)user_data;
    boite_saisie_carre(c);
    return TRUE; 
   }

   gboolean on_boutton_dessiner_rectangle(GtkButton *button, gpointer user_data)
   {
    Rectangle * r=(Rectangle*)user_data;
    boite_saisie_rectangle(r);
    return TRUE;
   }

   gboolean on_boutton_dessiner_cercle(GtkButton *button, gpointer user_data)
   {
    Cercle * cer=(Cercle*)user_data;
    boite_saisie_cercle(cer);
    return TRUE;
   }

   gboolean on_boutton_dessiner_plume(GtkButton *button, gpointer user_data)
   {
    Plume * p=(Plume*)user_data;
    boite_saisie_plume(p);
    return TRUE;
   }
   @endcode
*/
/**
   @file Boite_saisie_animation.c
   @brief Details du code de Boite_saisie_animation.c
   @code

   void boite_saisie_animation(Marqueur * mq,Scenario * sc)
   {
    champ_marqueur * cm=malloc(sizeof(champ_marqueur));
    Sc * S=malloc(sizeof(Sc));

    //Declaration de la fenetre et de la boite
    GtkWidget *pWindow,*pVBox;
  
    //Champs de saisie des parametres
    GtkWidget * champs_duree; 
    GtkWidget * champs_nom_marqueur; 
    GtkWidget * champs_position_scenario;
    GtkWidget * champs_position_tableau;
    GtkWidget * champs_vitesse;
    GtkWidget * champs_acceleration;
  
    GtkWidget *Button_ok,*Button_ok_scenario;
    GtkWidget *pLabel,*pLabel2,*pLabel3,*pLabel4,*pLabel5,*pLabel6;

    //Affichage de la fenetre
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Parametrage animation");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 150, 100);
    pVBox = gtk_box_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
  
    pLabel = gtk_label_new("Duree animation : milliseconde");
    pLabel2 = gtk_label_new("Nom Marqueur");
    pLabel3 = gtk_label_new("Position scenario : milliseconde");
    pLabel4 = gtk_label_new("Position tableau : un entier");
    pLabel5 = gtk_label_new("Vitesse : un double");
    pLabel6 = gtk_label_new("Acceleration : un double");

    champs_duree = gtk_entry_new();
    champs_nom_marqueur = gtk_entry_new();
    champs_position_scenario = gtk_entry_new();
    champs_position_tableau = gtk_entry_new();
    champs_vitesse = gtk_entry_new();
    champs_acceleration = gtk_entry_new();

    //Inclusion des champs de saisie dans la boite
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_duree, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel2, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_nom_marqueur, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_position_scenario, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel4, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_position_tableau, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel5, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_vitesse, TRUE, FALSE, 0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel6, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_acceleration, TRUE, FALSE, 0);

    Button_ok = gtk_button_new_with_label("Remplir marqueur");
    gtk_box_pack_start(GTK_BOX(pVBox),Button_ok, TRUE, FALSE, 0);
  
    Button_ok_scenario = gtk_button_new_with_label("Remplir scenario");
    gtk_box_pack_start(GTK_BOX(pVBox),Button_ok_scenario, TRUE, FALSE, 0);

    cm->m = mq;
    cm->Box = pVBox;

    //Appel de la fonction qui remplit la structure marqueur
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(RemplirStructureMarqueur),(champ_marqueur*)cm);
    
    S->m = cm->m;
    S->s = sc;

    //Appel de la fonction qui remplit la structure scenario
    g_signal_connect(G_OBJECT(Button_ok_scenario),"clicked",G_CALLBACK(RajouterMarqueur),(Sc*)S);
    
    gtk_widget_show_all(pWindow);
   }

   void RemplirStructureMarqueur(GtkWidget *pButton,gpointer data)
   {
    GtkWidget *champs;
    GList *list; //liste doublement chainee
    const gchar *texte_champs;
  
    Marqueur * mq;
    champ_marqueur * cm=(champ_marqueur*)data;
    mq=cm->m;

    //Recuperation de la liste des elements que contient la GtkVBox
    list = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)cm->Box));
    
    list = g_list_next(list);
    //On recupere le champ duree
    champs = GTK_WIDGET(list->data);
    //Recuperation du texte contenu dans le GtkEntry
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    //On convertit la chaine en int
    mq->duree=atoi(texte_champs);
  
    //On continue pour les autres champs
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    mq->nom_marqueur = texte_champs;
    
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    mq->position_scenario = atoi(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    mq->position_tableau = atoi(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    mq->vitesse=atof(texte_champs);
    
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    mq->acceleration=atof(texte_champs);
    
    g_list_free(list);
   }

   @endcode

*/
/**
   @file Boite_Saisie_Outils.c
   @brief Details du code Boite_Saisie_Outils.c
   @code
     
   static void AppelDessinerRec(GtkButton *button, gpointer user_data)
   {
    Rectangle * r = (Rectangle*)user_data;
    dessins = clutter_cairo_texture_new (r->dimX,r->dimY);
    //On dessine la forme sur l'ecran
    clutter_container_add_actor (CLUTTER_CONTAINER (stage), dessins);
    clutter_actor_add_constraint (dessins, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0));
    clutter_cairo_texture_set_auto_resize (CLUTTER_CAIRO_TEXTURE (dessins), TRUE);
    g_signal_connect(dessins, "draw", G_CALLBACK (DessinerRectangle),(Rectangle*)r);
   }
   static void AppelDessinerCar(GtkButton *button, gpointer user_data)
   {
    Carre * c = (Carre*)user_data;
    dessins = clutter_cairo_texture_new (c->dim,c->dim);
    clutter_container_add_actor (CLUTTER_CONTAINER (stage), dessins);
    clutter_actor_add_constraint (dessins, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0));
    clutter_cairo_texture_set_auto_resize (CLUTTER_CAIRO_TEXTURE (dessins), TRUE);
    g_signal_connect(dessins, "draw", G_CALLBACK (DessinerCarre),(Carre*)c);
   }
   static void AppelDessinerCercle(GtkButton *button, gpointer user_data)
   {
    Cercle * c = (Cercle*)user_data;
    dessins = clutter_cairo_texture_new (c->rayon*2,c->rayon*2);
    clutter_container_add_actor (CLUTTER_CONTAINER (stage), dessins);
    clutter_actor_add_constraint (dessins, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0));
    clutter_cairo_texture_set_auto_resize (CLUTTER_CAIRO_TEXTURE (dessins), TRUE);
    g_signal_connect(dessins, "draw", G_CALLBACK (DessinerCercle),(Cercle*)c);
   }
   static void AppelDessinerPlume(GtkButton *button, gpointer user_data)
   {
    Plume * p=(Plume*)user_data;
    dessins = clutter_cairo_texture_new (p->dimX,p->dimY);
    clutter_container_add_actor (CLUTTER_CONTAINER (stage), dessins);
    clutter_actor_add_constraint (dessins, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0));
    clutter_cairo_texture_set_auto_resize (CLUTTER_CAIRO_TEXTURE (dessins), TRUE);
    g_signal_connect(dessins, "draw", G_CALLBACK (DessinerPlume),(Plume*)p);
   }

   void boite_saisie_rectangle(Rectangle * rec)
   {
    //Note pour les structures : On alloue les structures dans le tas pour le passage de parametre
    //dans les fonctions G_CALLBACK sinon cela ne fonctionne pas. Par contre nous n'avons
    //pas trouve de solution pour liberer cette espace alloue sans faire planter l'application avec des erreurs
    //de segmentation

    champ_rectangle * cr=malloc(sizeof(champ_rectangle));
    GtkWidget * pWindow,* pVBox;
  
    //Champs de saisie des parametres
    GtkWidget *champs_coordoRecX,*champs_coordoRecY,*champs_dimX,*champs_dimY,*champs_epaisseur_contour,*champs_couleur_contourR;
    GtkWidget *champs_couleur_contourG,*champs_couleur_contourB,*champs_couleur_fondR,*champs_couleur_fondG,*champs_couleur_fondB;

    //Bouton pour valider la saisie et declaration des etiquettes
    GtkWidget * Button_ok;
    GtkWidget *pLabel1,*pLabel2,*pLabel3,*pLabel4,*pLabel5,*pLabel6,*pLabel7,*pLabel8,*pLabel9,
    *pLabel10,*pLabel11;

    //Affichage de la fenetre
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow),"Parametrage Rectangle");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 150, 100);
    pVBox = gtk_box_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    pLabel1 = gtk_label_new("Coordonnees en X : en double");
    pLabel2 = gtk_label_new("Coordonnees en Y : en double");
    pLabel3 = gtk_label_new("Longueur : en double");
    pLabel4 = gtk_label_new("Largeur : en double");
    pLabel5 = gtk_label_new("Epaisseur contour : en double");
    pLabel6 = gtk_label_new("Couleur contour R : un double");
    pLabel7 = gtk_label_new("Couleur contour G : un double");
    pLabel8 = gtk_label_new("Couleur contour B : un double");
    pLabel9 = gtk_label_new("Couleur fond R : un double");
    pLabel10 = gtk_label_new("Couleur fond G : un double");
    pLabel11 = gtk_label_new("Couleur fond B : un double");
   
    champs_coordoRecX = gtk_entry_new();
    champs_coordoRecY = gtk_entry_new();
    champs_dimX = gtk_entry_new();
    champs_dimY = gtk_entry_new();
    champs_epaisseur_contour = gtk_entry_new();
    champs_couleur_contourR = gtk_entry_new();
    champs_couleur_contourG = gtk_entry_new();
    champs_couleur_contourB = gtk_entry_new();
    champs_couleur_fondR = gtk_entry_new();
    champs_couleur_fondG = gtk_entry_new();
    champs_couleur_fondB = gtk_entry_new();
  
    //Inclusion des champs de saisie dans la boite
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel1, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoRecX, TRUE, FALSE, 0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel2, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoRecY, TRUE, FALSE, 0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_dimX, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel4, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_dimY, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel5, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_epaisseur_contour, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel6, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourR, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel7, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourG, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel8, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourB, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel9, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondR, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel10, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondG, TRUE, FALSE, 0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel11, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondB, TRUE, FALSE, 0);

    Button_ok = gtk_button_new_with_label("Valider");
    gtk_box_pack_start(GTK_BOX(pVBox),Button_ok, TRUE, FALSE, 0);

    cr->r = rec;
    cr->Box = pVBox;
  
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(RemplirStructureRectangle),(champ_rectangle*)cr);
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(AppelDessinerRec),(Rectangle*)cr->r);
  
    gtk_widget_show_all(pWindow);
   }

   void RemplirStructureRectangle(GtkWidget *pButton,gpointer data)
   {
    GtkWidget *champs;
    GList *list;
    const gchar *texte_champs;
    Rectangle * rec;

    champ_rectangle * cr=(champ_rectangle*)data;
    rec=cr->r;

    list = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)cr->Box));
  
    //On recupere pour le 1er champ Coordonnes en X
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));

    //On convertit la chaine en double
    rec->coordoRec.x=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->coordoRec.y=atof(texte_champs);
  
    //On continue pour les autres champs 3 Dimension en X du rectangle
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->dimX=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->dimY=atof(texte_champs);
   
    //Epaisseur du contour
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->epaisseur_contour=atof(texte_champs);
  
    //couleur contour
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->contour.r=atof(texte_champs);
   
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->contour.g=atof(texte_champs);
  
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->contour.b=atof(texte_champs);

    //Couleur du fond
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->fond.r=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->fond.g=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    rec->fond.b=atof(texte_champs);
  
    g_list_free(list);
   }

   //Saisie des parametres de la structure plume
   //Note : Pour la structure plume, initialement il etait prevu que
   //l'utilisateur puisse choisir le nombre de points de la forme
   //et que les champs apparaissent dynamiquement pour saisir les coordonnees de ces points.
   //Mais cela n'a pas fonctionne, du coup nous avons limite le nombre de points d'encrage a 3
   //Le fonction de l'outils plume ressemble au fonctionnement de la plume de bezier

   void boite_saisie_plume(Plume * pl)
   {
    champ_plume * cr=malloc(sizeof(champ_plume));
    GtkWidget * pWindow,* pVBox;

    //Coordonnees de la forme
    GtkWidget *champs_coordoPlumeX,*champs_coordoPlumeY;
   
    //Coordonnes des points d'encrage
    GtkWidget *champs_coordoPlumeX3_1,*champs_coordoPlumeY3_2,*champs_coordoPlumeX3_3,*champs_coordoPlumeY3_4;
    GtkWidget *champs_coordoPlumeX3_5,*champs_coordoPlumeY3_6;
    GtkWidget *champs_epaisseur_contour,*champs_couleur_contourR,*champs_couleur_contourG,*champs_couleur_contourB;
    GtkWidget *champs_couleur_fondR,*champs_couleur_fondG,*champs_couleur_fondB;

    GtkWidget * Button_ok;
    GtkWidget *pLabel1,*pLabel2,*pLabel3,*pLabel3_1,*pLabel3_2,*pLabel3_3,*pLabel3_4,
    *pLabel3_5,*pLabel3_6,*pLabel5,*pLabel6,*pLabel7,*pLabel8,*pLabel9,*pLabel10,*pLabel11;

    //Affichage de la fenetre
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Parametrage Plume");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 150, 100);
    pVBox = gtk_box_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);

    pLabel1 = gtk_label_new("Coordonnees en X : en double");
    pLabel2 = gtk_label_new("Coordonnees en Y : en double");
    pLabel3 = gtk_label_new("Liste de points d'encrage");
    pLabel3_1 = gtk_label_new("Coordonnees en X : en double");
    pLabel3_2 = gtk_label_new("Coordonnees en Y : en double");
    pLabel3_3 = gtk_label_new("Coordonnees en X : en double");
    pLabel3_4 = gtk_label_new("Coordonnees en Y : en double");
    pLabel3_5 = gtk_label_new("Coordonnees en X : en double");
    pLabel3_6 = gtk_label_new("Coordonnees en Y : en double");
    pLabel5 = gtk_label_new("Epaisseur contour : en double");
    pLabel6 = gtk_label_new("Couleur contour R : un double");
    pLabel7 = gtk_label_new("Couleur contour G : un double");
    pLabel8 = gtk_label_new("Couleur contour B : un double");
    pLabel9 = gtk_label_new("Couleur Fond R : un double");
    pLabel10 = gtk_label_new("Couleur Fond G : un double");
    pLabel11 = gtk_label_new("Couleur Fond B : un double");
  
    champs_coordoPlumeX = gtk_entry_new();
    champs_coordoPlumeY = gtk_entry_new();
    champs_coordoPlumeX3_1 = gtk_entry_new();
    champs_coordoPlumeY3_2 = gtk_entry_new();
    champs_coordoPlumeX3_3 = gtk_entry_new();
    champs_coordoPlumeY3_4 = gtk_entry_new();
    champs_coordoPlumeX3_5 = gtk_entry_new();
    champs_coordoPlumeY3_6 = gtk_entry_new();
    champs_epaisseur_contour = gtk_entry_new();
    champs_couleur_contourR = gtk_entry_new();
    champs_couleur_contourG = gtk_entry_new();
    champs_couleur_contourB = gtk_entry_new();
    champs_couleur_fondR = gtk_entry_new();
    champs_couleur_fondG = gtk_entry_new();
    champs_couleur_fondB = gtk_entry_new();

    //Inclusion des champs de saisie dans la boite
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel1, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoPlumeX, TRUE, FALSE,0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel2, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoPlumeY, TRUE, FALSE,0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3, TRUE, FALSE, 0);

    //1er point d'encrage:
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3_1, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoPlumeX3_1, TRUE, FALSE,0);
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3_2, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoPlumeY3_2, TRUE, FALSE,0);
    //2eme :
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3_3, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoPlumeX3_3, TRUE, FALSE,0);
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3_4, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoPlumeY3_4, TRUE, FALSE,0);
    //3eme :
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3_5, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoPlumeX3_5, TRUE, FALSE,0);
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3_6, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoPlumeY3_6, TRUE, FALSE,0);
    //Fin liste points d'encrage

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel5, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_epaisseur_contour, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel6, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourR, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel7, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourG, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel8, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourB, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel9, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondR, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel10, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondG, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel11, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondB, TRUE, FALSE, 0);
  
    Button_ok = gtk_button_new_with_label("OK");
    gtk_box_pack_start(GTK_BOX(pVBox),Button_ok, TRUE, FALSE, 0);

    cr->p = pl;
    cr->Box = pVBox;
  
    //Appel de la fonction qui remplit la structure marqueur
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(RemplirStructurePlume),(champ_plume*)cr);
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(AppelDessinerPlume),(Plume*)cr->p);
    gtk_widget_show_all(pWindow);
   }

   void RemplirStructurePlume(GtkWidget *pButton,gpointer data)
   {
    int i;Coordonnees cor;
    GtkWidget *champs;
    GList *list;
    const gchar *texte_champs;

    Plume * pl;
    champ_plume * cr=(champ_plume*)data;
    pl=cr->p;

    list = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)cr->Box));
  
    //Meme principe que pour la structure Rectangle
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->coorPl.x=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->coorPl.y=atof(texte_champs);

    //Recuperation des 3 points d'encrage
    //1er
    list = g_list_next(list);
    list = g_list_next(list);
    list = g_list_next(list);

    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cor.x = atoi(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cor.y = atoi(texte_champs);
  
    //Ajout du point dans le tab_dynamique de la structure plume
    RajouterPointEncrage(pl,cor);

    //2eme
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cor.x = atoi(texte_champs);
    
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cor.y = atoi(texte_champs);
    
    RajouterPointEncrage(pl,cor);

    //3eme
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cor.x = atoi(texte_champs);
    
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cor.y = atoi(texte_champs);

    RajouterPointEncrage(pl,cor);
    //Fin ajout point d'encrage
  
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->epaisseur_contour=atof(texte_champs);

    //Couleur contour
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->contour.r=atof(texte_champs);
 
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->contour.g=atof(texte_champs);
 
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->contour.b=atof(texte_champs);
  
    //Couleur du fond
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->fond.r=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->fond.g=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    pl->fond.b=atof(texte_champs);

    //Calcul de la dimension
    pl->dimX = 0;
    pl->dimY = 0;

    for(i=0;i<pl->tab_coordonnees->len;i++)
    {
      pl->dimX = pl->dimX + g_array_index(pl->tab_coordonnees,Coordonnees,i).x;
      pl->dimY = pl->dimY + g_array_index(pl->tab_coordonnees,Coordonnees,i).y;
    }

    g_list_free(list);
   }

   void boite_saisie_cercle(Cercle * cer)
   {
    champ_cercle * cr=malloc(sizeof(champ_cercle));
    //Declaration de la fenetre et de la boite
    GtkWidget *pWindow,*pVBox;
  
    //Champs de saisie des parametres
    GtkWidget *champs_coordoCerX,*champs_coordoCerY,*champs_rayon,*champs_epaisseur_contour;
    GtkWidget *champs_couleur_contourR,*champs_couleur_contourG,*champs_couleur_contourB;
    GtkWidget *champs_couleur_fondR,*champs_couleur_fondG,*champs_couleur_fondB;

    GtkWidget *Button_ok;
    GtkWidget *pLabel1,*pLabel2,*pLabel3,*pLabel4,*pLabel5,*pLabel6,*pLabel7,*pLabel8,*pLabel9,*pLabel10;

    //Affichage de la fenetre*
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Parametrage Cercle");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 150, 100);
    pVBox = gtk_box_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
  
    //Declaration des champs de saisie
    pLabel1 = gtk_label_new("Coordonnees en X : en double");
    pLabel2 = gtk_label_new("Coordonnees en Y : en double");
    pLabel3 = gtk_label_new("Rayon : en entier");
    pLabel4 = gtk_label_new("Epaisseur contour : en entier");
    pLabel5 = gtk_label_new("Couleur contour R : un double");
    pLabel6 = gtk_label_new("Couleur contour G : un double");
    pLabel7 = gtk_label_new("Couleur contour B : un double");
    pLabel8 = gtk_label_new("Couleur Fond R : un double");
    pLabel9 = gtk_label_new("Couleur Fond G : un double");
    pLabel10 = gtk_label_new("Couleur Fond B : un double");
  
    champs_coordoCerX = gtk_entry_new();
    champs_coordoCerY = gtk_entry_new();
    champs_rayon = gtk_entry_new();
    champs_epaisseur_contour = gtk_entry_new();
    champs_couleur_contourR = gtk_entry_new();
    champs_couleur_contourG = gtk_entry_new();
    champs_couleur_contourB = gtk_entry_new();
    champs_couleur_fondR = gtk_entry_new();
    champs_couleur_fondG = gtk_entry_new();
    champs_couleur_fondB = gtk_entry_new();

    //Inclusion des champs de saisie dans la boite
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel1, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoCerX, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel2, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoCerY, TRUE, FALSE, 0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_rayon, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel4, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_epaisseur_contour, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel5, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourR, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel6, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourG, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel7, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourB, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel8, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondR, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel9, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondG, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel10, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondB, TRUE, FALSE, 0);
    
    Button_ok = gtk_button_new_with_label("OK");
    gtk_box_pack_start(GTK_BOX(pVBox),Button_ok, TRUE, FALSE, 0);

    cr->c = cer;
    cr->Box = pVBox;
  
    //Appel de la fonction qui remplit la structure marqueur
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(RemplirStructureCercle),(champ_cercle*)cr);
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(AppelDessinerCercle),(Cercle*)cr->c);
    gtk_widget_show_all(pWindow);
   }

   //Remplissage de la structure Cercle
   void RemplirStructureCercle(GtkWidget *pButton,gpointer data)
   {
    GtkWidget *champs;
    GList *list;
    const gchar *texte_champs;
    Cercle * cer;
    
    champ_cercle * cr=(champ_cercle*)data;
    cer=cr->c;

    //Recuperation de la liste des elements que contient la GtkVBox
    list = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)cr->Box));
    
    //On recupere les Coordonnes
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->coordoCer.x=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->coordoCer.y=atof(texte_champs);

    //On recupere le Rayon
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->rayon=atoi(texte_champs);
 
    //Epaisseur contour
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->epaisseur_contour=atoi(texte_champs);

    //Couleur Contour
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->contour.r=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->contour.g=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->contour.b=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->fond.r=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->fond.g=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    cer->fond.b=atof(texte_champs);
    
    g_list_free(list);
   }

   void boite_saisie_carre(Carre * car)
   {
    champ_carre * cm=malloc(sizeof(champ_carre));
    //Declaration de la fenetre et de la boite
    GtkWidget *pWindow,*pVBox;
    
    //Champs de saisie des parametres
    GtkWidget *champs_coordoCarX,*champs_coordoCarY,*champs_dim,*champs_epaisseur_contour;
    GtkWidget *champs_couleur_contourR,*champs_couleur_contourG,*champs_couleur_contourB;
    GtkWidget *champs_couleur_fondR,*champs_couleur_fondG,*champs_couleur_fondB;

    GtkWidget * Button_ok;
    GtkWidget *pLabel1,*pLabel2,*pLabel3,*pLabel4,*pLabel5,*pLabel6,*pLabel7,*pLabel8,*pLabel9,*pLabel10;
   
    //Affichage de la fenetre
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Parametrage Carre");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 150, 100);
    pVBox = gtk_box_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);

    pLabel1 = gtk_label_new("Coordonnees en X : en double");
    pLabel2 = gtk_label_new("Coordonnees en Y : en double");
    pLabel3 = gtk_label_new("Dimension : en double");
    pLabel4 = gtk_label_new("Epaisseur contour : en double");
    pLabel5 = gtk_label_new("Couleur contour R : un double");
    pLabel6 = gtk_label_new("Couleur contour G : un double");
    pLabel7 = gtk_label_new("Couleur contour B : un double");
    pLabel8 = gtk_label_new("Couleur Fond R : un double");
    pLabel9 = gtk_label_new("Couleur Fond G : un double");
    pLabel10 = gtk_label_new("Couleur Fond B : un double");
  
    champs_coordoCarX = gtk_entry_new();
    champs_coordoCarY = gtk_entry_new();
    champs_dim = gtk_entry_new();
    champs_epaisseur_contour = gtk_entry_new();
    champs_couleur_contourR = gtk_entry_new();
    champs_couleur_contourG = gtk_entry_new();
    champs_couleur_contourB = gtk_entry_new();
    champs_couleur_fondR = gtk_entry_new();
    champs_couleur_fondG = gtk_entry_new();
    champs_couleur_fondB = gtk_entry_new();

    //Inclusion des champs de saisie dans la boite
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel1, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoCarX, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel2, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_coordoCarY, TRUE, FALSE, 0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel3, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_dim, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel4, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_epaisseur_contour, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel5, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourR, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel6, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourG, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel7, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_contourB, TRUE, FALSE, 0);
  
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel8, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondR, TRUE, FALSE, 0);
    
    gtk_box_pack_start(GTK_BOX(pVBox),pLabel9, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondG, TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(pVBox),pLabel10, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox),champs_couleur_fondB, TRUE, FALSE, 0);
  
    Button_ok = gtk_button_new_with_label("OK");
    gtk_box_pack_start(GTK_BOX(pVBox),Button_ok, TRUE, FALSE, 0);

    cm->c = car;
    cm->Box = pVBox;
    
    //Appel de la fonction qui remplit la structure marqueur
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(RemplirStructureCarre),(champ_carre*)cm);
    g_signal_connect(G_OBJECT(Button_ok),"clicked",G_CALLBACK(AppelDessinerCar),(Carre*)cm->c);
    gtk_widget_show_all(pWindow);
   }

   void RemplirStructureCarre(GtkWidget *pButton,gpointer data)
   {
    GtkWidget *champs;
    GList *list;
    const gchar *texte_champs;
    Carre * car;
    champ_carre * cm=(champ_carre*)data;
    car=cm->c;
  
    list = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)cm->Box));
  
    //Recuperation des Coordonnes
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->coordoCar.x=atof(texte_champs);
    
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->coordoCar.y=atof(texte_champs);

    //Recuperation de la dimension
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->dim=atof(texte_champs);
 
    //Recuperation de l epaisseur du contour
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->epaisseur_contour=atof(texte_champs);

    //Couleur contour
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->contour.r=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->contour.g=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->contour.b=atof(texte_champs);

    //Couleur Fond
    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->fond.r=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->fond.g=atof(texte_champs);

    list = g_list_next(list);
    list = g_list_next(list);
    champs = GTK_WIDGET(list->data);
    texte_champs = gtk_entry_get_text(GTK_ENTRY(champs));
    car->fond.b=atof(texte_champs);

    g_list_free(list);
   }
   @endcode
*/

/**
   @file main.c
   @brief Description du code main.c
   @code
   int main(int argc, char *argv[])                                                                                                     {                                                                                                                                     Carre c;
    Rectangle rec;
    Cercle cer;
    Plume p;
    Scenario sc;
    Marqueur mq;
    InitScenario(&sc);

    gtk_clutter_init (&argc, &argv);
    AfficherEcran();
    CreerMenu();
    CreationBarreOutilsDessins(c,rec,cer,p);
    CreationBarreOutilsAnimation(&sc,&mq);
    gtk_main();

    return EXIT_SUCCESS;
   }
   @endcode
*/

/**
   @file Animation.c
   @brief Details des fonctions internes et externes du fichier
   @code
   ClutterActor * dessins;
   static void GD(ClutterTimeline *timeline, gint frame_num, gpointer data)
   {
    Marqueur * m=(Marqueur*)data;
    gdouble vitesse,acceleration;
    vitesse = m->vitesse;
    acceleration = m->acceleration;
    vitesse = vitesse + acceleration;
    clutter_actor_move_by(dessins,vitesse,0);
   }

   void DeplacementGD(ClutterTimeline *timeline,gchar * marker_name,gint msecs,gpointer data)
   {
    Marqueur * m=(Marqueur*)data;
    timeline = clutter_timeline_new(m->duree);
    clutter_timeline_set_repeat_count(timeline,0);
    clutter_timeline_start(timeline);
    g_signal_connect(timeline,"new-frame",G_CALLBACK(GD),(Marqueur*)m);
   }

   static void HB(ClutterTimeline *timeline, gint frame_num, gpointer data)
   {
    Marqueur * m=(Marqueur*)data;
    gdouble vitesse,acceleration;
    vitesse = m->vitesse;
    acceleration = m->acceleration;
    vitesse = vitesse + acceleration;
    clutter_actor_move_by (dessins,0,vitesse);
   }

   void DeplacementHB(ClutterTimeline *timeline,gchar * marker_name,gint msecs,gpointer data)
   {
    Marqueur * m=(Marqueur*)data;
    timeline = clutter_timeline_new(m->duree);
    clutter_timeline_set_repeat_count(timeline,0);
    clutter_timeline_start(timeline);
    g_signal_connect(timeline,"new-frame",G_CALLBACK(HB),(Marqueur*)m);
   }

   static void CDX(ClutterTimeline *timeline, gint frame_num, gpointer data)
   {
    Marqueur * m=(Marqueur*)data;
    gdouble vitesse,acceleration;
    vitesse = m->vitesse;
    acceleration = m->acceleration;
    vitesse = vitesse + acceleration;
    clutter_actor_set_scale(dessins,vitesse,1);
   }

   void ChangementDechelleX(ClutterTimeline *timeline,gchar * marker_name,gint msecs,gpointer data)
   {
    Marqueur * m=(Marqueur*)data;
    timeline = clutter_timeline_new(m->duree);
    clutter_timeline_set_repeat_count(timeline,0);
    clutter_timeline_start(timeline);
    g_signal_connect(timeline,"new-frame",G_CALLBACK(CDX),(Marqueur*)m);
   }

  static void RZ(ClutterTimeline *timeline, gint frame_num, gpointer data)
  {
   Marqueur * m=(Marqueur*)data;
   gdouble vitesse,acceleration;
   vitesse = m->vitesse;
   acceleration = m->acceleration;
   vitesse = vitesse + acceleration;
   clutter_actor_set_rotation(dessins,CLUTTER_Z_AXIS,vitesse*5, 0, 0,0);
  }

  void RotationZ(ClutterTimeline *timeline,gchar * marker_name,gint msecs,gpointer data)
  {
   Marqueur * m=(Marqueur*)data;
   timeline = clutter_timeline_new(m->duree);
   clutter_timeline_set_repeat_count(timeline,0);
   clutter_timeline_start(timeline);
   g_signal_connect(timeline,"new-frame",G_CALLBACK(RZ),(Marqueur*)m);
  }
  @endcode  
*/   

/**
   @file Scenario.c
   @brief Detail du code de Scenario.c
   @code

   //Precondition : Scenario non initialise
   void InitScenario(Scenario * sc)
   {
     sc->tab_mq=g_array_new(FALSE,FALSE,sizeof(Marqueur));
   }

   //Precondition : Scenario initialise                                                                               
   //Postcondition : Rajoute un marqueur au scenario
   void RajouterMarqueur(GtkWidget *pButton,gpointer data)
   {
   Sc * S = (Sc*)data;
     g_array_append_val(S->s->tab_mq,*(S->m));
   }

   //Precondition : Scenario initialise, i position du marqueur dans le scenario
   void ModifMarqueur(Scenario * sc,Marqueur mq,unsigned int i)
   {
     g_array_remove_index(sc->tab_mq,i);
     g_array_insert_val(sc->tab_mq,i,mq);
   }

   //Precondition : Scenario initialise
   void SuppMarqueur(Scenario * sc,unsigned int i)
   {
     g_array_remove_index(sc->tab_mq,i);
   }

   //Precondition : Scenario initialisee
   //Postcondition : Le Scenario ne peut plus etre utilisee                                                                      /*la   //memoire alloue pour le tableau est supprimee
   void SuppScenario(Scenario * sc)
   {
     g_array_free(sc->tab_mq,FALSE);
   }
   
   //Fonction qui deroule le scenario
   void DeroulerScenario(GtkWidget *pButton,gpointer user_data)
   {
     int i;
     gchar * dest;
     gchar tmp[250]="marker-reached::";
    
     Sc * S=(Sc*)user_data;
  
     Marqueur * m;
    
     //On declare la longueur de l'animation
     ClutterTimeline *timeline = clutter_timeline_new(10000);
     clutter_timeline_start(timeline);
        
     for(i=0;i<S->s->tab_mq->len;i++)
     {
      m = &g_array_index(S->s->tab_mq,Marqueur,i);
      //On met en place le marqueur
      clutter_timeline_add_marker_at_time(timeline,m->nom_marqueur,m->position_scenario);
      dest = m->nom_marqueur;
      strcat(tmp,dest);
            
      switch(m->index_fonction){
	    
      case 1 :
	      
	//On appele la fonction correspondante a l'index 1
	g_signal_connect(timeline,tmp,G_CALLBACK(DeplacementGD),(Marqueur*)m);
	break;
	      
      case 2 :
	            
	//On appele la fonction correspondante a l'index 1
	g_signal_connect(timeline,tmp,G_CALLBACK(DeplacementHB),(Marqueur*)m);
	break;
	
      case 3 :
	     
	//On appele la fonction correspondante a l'index 1
	g_signal_connect(timeline,tmp,G_CALLBACK(ChangementDechelleX),(Marqueur*)m);
	break;
	
      case 4 :
	      
	//On appele la fonction correspondante a l'index 1
	g_signal_connect(timeline,tmp,G_CALLBACK(RotationZ),(Marqueur*)m);
	break;
	
      default : printf("ERREUR FATALE\n");
	      
	clutter_timeline_remove_marker(timeline,m->nom_marqueur);
	
	}
      
      }
  
    }
    @endcode
*/
/**
   @file Carre.c
   @brief Detail du code du Carre.c
   @code
   //Precondition : Carre non initialisee                                                                                                               
   //Postcondition : Carre initialisee
   void InitCarre(Carre * car)
   {
     car->coordoCar.x=0;
     car->coordoCar.y=0;
     car->contour.r=0;
     car->contour.g=0;
     car->contour.b=0;
     car->fond.r=0;
     car->fond.g=0;
     car->fond.b=0;
     car->dim=0;
     car->epaisseur_contour=0; 
   }
   //Precondition : Carre initialisee
   
   void CreerCarre(Carre * car,double dim, double epaisseur_contour, Couleur fond, Couleur contour, Coordonnees c)
   {
     assert(dim>=0 && epaisseur_contour >=0);
     assert(c.x>=0 && c.y>=0);
     car->coordoCar.x=c.x;
     car->coordoCar.y=c.y;
     car->contour.r=contour.r;
     car->contour.g=contour.g;
     car->contour.b=contour.b;
     car->fond.r=fond.r;
     car->fond.g=fond.g;
     car->fond.b=fond.b;
     car->dim=dim;
     car->epaisseur_contour=epaisseur_contour; 
   }
				   
   //Precondition : Carre initialisee
   void ModifierFondCarre(Carre * car,Couleur fond)
   {
     car-> fond.r=fond.r;
     car-> fond.g=fond.g;
     car-> fond.g=fond.b;
   }
   
   //Precondition : Carre initialisee et la dimension est une valeur positive
   void ModifierTailleCarre(Carre * car,int dim)
   {
     assert(dim>=0);
     car->dim=dim;
   }
				   
   //Precondition : Carre initialisee
   void ModifierContourCarre(Carre * car,int epaisseur_contour,Couleur contour)
   {
     assert(epaisseur_contour>=0);
     car->contour.r=contour.r;
     car->contour.g=contour.g;
     car->contour.b=contour.b;
     car->epaisseur_contour=epaisseur_contour; 
   }
   
   //Precondition : Carre initialisee
   void ModifierCoordonneesCarre(Carre * car,Coordonnees c)
   {
     assert(c.x>=0 && c.y>=0);
     car->coordoCar.x=c.x;
     car->coordoCar.y=c.y;
   }
   
   void SupprimerCarre(Carre * car){}
   @endcode
*/

/**
   @file Cercle.c
   @brief Detail du code Cercle.c
   @code
   //Precondition : Cercle non initialisee                                                                                                     
   //Postcondition : Cercle initialisee
   void InitCercle(Cercle * cer)
   {
   cer->coordoCer.x=0;
   cer->coordoCer.y=0;
   cer->rayon=0;
   cer-> epaisseur_contour=0;
   cer->contour.r=0;
   cer->contour.g=0;
   cer->contour.b=0;
   cer->fond.r=0;
   cer->fond.g=0;
   cer->fond.b=0;
   }
   
   //Precondition : Cercle initialisee
   void CreerCercle(Cercle * cer,int rayon, int epaisseur_contour, Couleur fond, Couleur contour,Coordonnees c)
   {
   
   assert(c.x >= 0 && c.y>= 0 && rayon >=0 && epaisseur_contour >= 0);
   assert(fond.r <=255 && fond.r >=0 && fond.g <=255 && fond.g >=0 && fond.b <=255 && fond.b >=0);
   cer->coordoCer.x=c.x;
   cer->coordoCer.y=c.y;
   cer->rayon=rayon;
   cer-> epaisseur_contour= epaisseur_contour;
   cer->contour.r=contour.r;
   cer->contour.g= contour.g;
   cer->contour.b=contour.b;
   cer->fond.r=fond.r;
   cer->fond.g=fond.g;
   cer->fond.b=fond.b;
   
   }
   
   //Precondition : Cercle initialisee
   void ModifierFondCercle(Cercle * cer,Couleur fond)
   {
     assert(fond.r <=255 && fond.r >=0 && fond.g <=255 && fond.g >=0 && fond.b <=255 && fond.b >=0);
     cer->fond.r=fond.r;
     cer->fond.g=fond.g;
     cer->fond.b=fond.b;
   }
   
   //ModifierTailleCercle modifie le rayon du cercle
   //Precondition : Cercle initialisee
   void ModifierTailleCercle(Cercle * cer,int rayon)
   {
     assert(rayon>=0);
     cer->rayon=rayon;
   }
   
   //ModifierContourCercle modifie l'epaisseur du cercle et la couleur du contour
   //Precondition : Cercle initialisee
   void ModifierContourCercle(Cercle * cer,int epaisseur_contour,Couleur contour)
   {
     assert(epaisseur_contour >= 0 );
     assert(contour.r <=255 && contour.r >=0 && contour.g <=255 && contour.g >=0 && contour.b <=255 && contour.b >=0);
     cer->epaisseur_contour = epaisseur_contour;
     cer->contour.r=contour.r;
     cer->contour.g=contour.g;
     cer->contour.b=contour.b;
   }
   
   //ModifierCoordonneesCercle modifie le de coordonnees (x,y)
   //Precondition : Cercle initialisee 
   void ModifierCoordonneesCercle(Cercle * cer,Coordonnees c)
   {
     assert(c.x >= 0 && c.y >= 0);
     cer->coordoCer.x=c.x;
     cer->coordoCer.y=c.y;
   }
   
   //getDiametre r?cup?re le diametre du cercle en v?rifiant leur validit? 
   //formule diam = rayon * 2
   int getDiametre(int rayon)
   {
     assert(rayon >= 0);
     return (rayon*2);
   }
   @endcode
*/

/**
   @file Dessiner.c
   @brief Detail du code Dessiner.c
   @code
   
   void DessinerCarre(ClutterCairoTexture * Dessins,cairo_t * cr,Carre * car)
   {
     //Pour eviter de superposer les differents objets
     clutter_cairo_texture_clear (Dessins);

     //1 On rempli le Carre avec la couleur de fond
     cairo_set_source_rgb(cr,car->fond.r,car->fond.g,car->fond.b);
     cairo_rectangle(cr,car->coordoCar.x,car->coordoCar.y,car->dim,car->dim);
     cairo_fill(cr);

     //2 On s'occupe du contours
     cairo_set_line_width (cr,car->epaisseur_contour);
     cairo_set_line_cap(cr,CAIRO_LINE_CAP_SQUARE);
     cairo_set_source_rgb (cr,car->contour.r,car->contour.g,car->contour.b);
     cairo_rectangle(cr,car->coordoCar.x,car->coordoCar.y,car->dim,car->dim);
     cairo_stroke(cr);
   }

   void DessinerRectangle(ClutterCairoTexture * Dessins,cairo_t * cr,Rectangle * rec)
   {  
  
     //Pour eviter de superposer les differents objets
     clutter_cairo_texture_clear (Dessins);
  
     //On dessine ensuite le rectangle a l'aide de la structure rectangle
     //1 On rempli le rectangle avec la couleur de fond
     cairo_set_source_rgb(cr,rec->fond.r,rec->fond.g,rec->fond.b);
     cairo_rectangle(cr,rec->coordoRec.x,rec->coordoRec.y,rec->dimX,rec->dimY);
     cairo_fill(cr);

     //2 On s'occupe du contours
     cairo_set_line_width (cr,rec->epaisseur_contour);
     cairo_set_line_cap(cr,CAIRO_LINE_CAP_SQUARE);
     cairo_set_source_rgb (cr,rec->contour.r,rec->contour.g,rec->contour.b);
     cairo_rectangle(cr,rec->coordoRec.x,rec->coordoRec.y,rec->dimX,rec->dimY);
     cairo_stroke(cr);
   }

   void DessinerPlume(ClutterCairoTexture * Dessins,cairo_t * cr,Plume * p)
   {
     int i;
     //Pour eviter de superposer les differents objets
     clutter_cairo_texture_clear (Dessins);

     //On dessine d'abord le contour
     cairo_move_to(cr,p->coorPl.x,p->coorPl.y);

     cairo_set_line_width (cr,p->epaisseur_contour);
     cairo_set_line_cap(cr,CAIRO_LINE_CAP_SQUARE);
     cairo_set_source_rgb (cr,p->contour.r,p->contour.g,p->contour.b);
  
     for(i=0;i<p->tab_coordonnees->len;i++)
     {
       cairo_rel_line_to(cr,g_array_index(p->tab_coordonnees,Coordonnees,i).x,
			g_array_index(p->tab_coordonnees,Coordonnees,i).y);
     }
     cairo_close_path (cr);
     cairo_stroke(cr);

     //On rempli ensuite la forme
     cairo_move_to (cr,p->coorPl.x,p->coorPl.y);
     
     for(i=0;i<p->tab_coordonnees->len;i++)
     {
      cairo_rel_line_to(cr,g_array_index(p->tab_coordonnees,Coordonnees,i).x,
			g_array_index(p->tab_coordonnees,Coordonnees,i).y);
     }
     cairo_close_path (cr);

     cairo_set_source_rgb(cr,p->fond.r,p->fond.g,p->fond.b);
     cairo_fill(cr);
   }

   void DessinerCercle(ClutterCairoTexture * Dessins,cairo_t * cr,Cercle * cer)
   {
     //Pour eviter de superposer les differents objets
     clutter_cairo_texture_clear (Dessins);
     
     cairo_set_source_rgb (cr,cer->fond.r,cer->fond.g,cer->fond.b);
     
     cairo_arc (cr, cer->coordoCer.x, cer->coordoCer.y, cer->rayon, 0.0,2 * M_PI);
     cairo_fill(cr);
  
     //2 On s'occupe du contours
     cairo_set_line_width(cr, cer->epaisseur_contour);
     cairo_set_line_cap(cr,CAIRO_LINE_CAP_SQUARE);
     cairo_set_source_rgb (cr,cer->contour.r,cer->contour.g,cer->contour.b);
     cairo_arc(cr, cer->coordoCer.x, cer->coordoCer.y, cer->rayon, 0.0, 2 * M_PI);
  
     cairo_stroke (cr);
   }

   //Precondition : carre modifi? au prealable par le module carre
   //Postcondition : On renvoie un nouveau dessin en ecrasant ancien
   void MettreAjourCarre(ClutterCairoTexture * Dessins,cairo_t * cr,Carre * car)
   {
     DessinerCarre(Dessins,cr,car);
   }

   //Precondition : cercle modifie au prealable par le module rectangle
   //Postcondition : On renvoie un nouveau dessin en ecrasant ancien
   void MettreAjourRectangle(ClutterCairoTexture * Dessins,cairo_t * cr,Rectangle * rec)
   {
     DessinerRectangle(Dessins,cr,rec);
   }

   //Precondition : cercle modifie au prealable par le module cercle
   //Postcondition : On renvoie un nouveau dessin en ecrasant ancien
   void MettreAjourCercle(ClutterCairoTexture * Dessins,cairo_t * cr,Cercle * cer)
   {
     DessinerCercle(Dessins,cr,cer);
   }

   //Precondition : plume modifi?e au prealable par le module plume
   Postcondition : On renvoie un nouveau dessin en ecrasant ancien
   void MettreAjourPlume(ClutterCairoTexture * Dessins,cairo_t * cr,Plume * p)
   {
     DessinerPlume(Dessins,cr,p);
   }
   @endcode
*/

/**
   @file Menu.c
   @brief Detail du code Menu.c

   void CreerMenu()
   {
     GtkWidget *pWindow;
     GtkWidget *pVBox;
     GtkWidget *pMenuBar;
     GtkWidget *pMenu;
     GtkWidget *pMenuItem;

     pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     gtk_window_set_title(GTK_WINDOW(pWindow), "GtkMenu");
     gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 100);
     g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);


     pVBox = gtk_vbox_new(FALSE, 0);
     gtk_container_add(GTK_CONTAINER(pWindow), pVBox);

     //Creation du menu
     pMenuBar = gtk_menu_bar_new();
     pMenu = gtk_menu_new();
  
     pMenuItem = gtk_menu_item_new_with_label("Nouveau");
     g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnNouveau), (GtkWidget*) pWindow);
     gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

     pMenuItem = gtk_menu_item_new_with_label("Ouvrir");
     g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnOuvrir), (GtkWidget*) pWindow);
     gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

     pMenuItem = gtk_menu_item_new_with_label("Enregistrer");
     g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnSauver), (GtkWidget*) pWindow);
     gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
     
     pMenuItem = gtk_menu_item_new_with_label("Fermer");
     g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnQuitter), (GtkWidget*) pWindow);
     gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

     pMenuItem = gtk_menu_item_new_with_label("Fichier");

     gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
     
     gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
     
     //Ajout du menu a la fenetre
     gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0);
     gtk_widget_show_all(pWindow);

   }

   void OnQuitter(GtkWidget* widget, gpointer data)
   {
     GtkWidget *pQuestion;
     pQuestion = gtk_message_dialog_new(GTK_WINDOW(data),GTK_DIALOG_MODAL,GTK_MESSAGE_QUESTION,GTK_BUTTONS_YES_NO,
     "Voulez vous vraiment\n""quitter le programme?");
     switch(gtk_dialog_run(GTK_DIALOG(pQuestion)))
     {
       case GTK_RESPONSE_YES:gtk_main_quit();
       break;

       case GTK_RESPONSE_NONE:
       
       case GTK_RESPONSE_NO:gtk_widget_destroy(pQuestion);
       break;
     }
   }
   void OnOuvrir(GtkWidget* widget, gpointer data)
   {
   }
   void OnSauver(GtkWidget* widget, gpointer data)
   {
   }
   void OnNouveau(GtkWidget* widget, gpointer data)
   {
   }
   @endcode
*/

/**
   @file Plume.c 
   @brief Detail du code Plume.c
   @code
  
/*Precondition : Plume non initialisee                                                                                               
Postcondition : Plume initialisee*/
void InitPlume(Plume *p)
{
  p->coorPl.x=0;
  p->coorPl.y=0;

  p->contour.r=0;
  p->contour.g=0;
  p->contour.b=0;

  p->fond.r=0;
  p->fond.g=0;
  p->fond.b=0;

  p->dimX=0;
  p->dimY=0;
  p->epaisseur_contour=0;
  
  p->tab_coordonnees=g_array_new(FALSE,FALSE,sizeof(Coordonnees));
}

/*Precondition : Plume initialisee*/
void CreerPlume(Plume *p,double epaisseur_contour,double dimX,double dimY,Coordonnees c,Couleur contour,Couleur fond)
{
  assert(dimX >= 0 && dimY >= 0 && epaisseur_contour >=0);
  assert(c.x>=0 && c.y>=0);
  
  p->coorPl.x=c.x;
  p->coorPl.y=c.y;

  p->contour.r=contour.r;
  p->contour.g=contour.g;
  p->contour.b=contour.b;

  p->fond.r=fond.r;
  p->fond.g=fond.g;
  p->fond.b=fond.b;
  
  p->dimX=dimX;
  p->dimY=dimY;

  p->epaisseur_contour=epaisseur_contour;
}


/*Precondition : Plume initialisee*/
void ModifierFondPlume(Plume *p,Couleur fond)
{
  p->fond.r=fond.r;
  p->fond.g=fond.g;
  p->fond.b=fond.b;
}

/*Precondition : Plume initialisee, dimX et dimY >=0*/
void ModifierTaillePlume(Plume *p,unsigned int dimX,unsigned int dimY)
{
  assert(dimX >= 0 && dimY >= 0);
  p->dimX=dimX;
  p->dimY=dimY;
}

/*Precondition : Plume initialisee, epaisseur_contour >=0)*/
void ModifierContourPlume(Plume *p,Couleur contour,unsigned int epaisseur_contour)
{
  assert(epaisseur_contour>=0);
  p->contour.r=contour.r;
  p->contour.g=contour.g;
  p->contour.b=contour.b;

  p->epaisseur_contour=epaisseur_contour;
}
/*Precondition : Plume initialisee*/
void ModifierCoordonneesPlume(Plume *p,Coordonnees c)
{
  assert(c.x>=0 && c.y>=0);
  p->coorPl.x=c.x;
  p->coorPl.y=c.y;
}

/*Precondition : Plume initialisee*/
/*Postcondition : une coordonnees est rajoutee dans le tab de coordonnees
  en fin de tableau*/
void RajouterPointEncrage(Plume *p,Coordonnees c)
{
  g_array_append_val(p->tab_coordonnees,c);
}

/*Precondition : Plume initialisee i <=taille utilise du tableau de coordonnees*/
void ModifPointEncrage(Plume *p,unsigned int i,Coordonnees c)
{
  g_array_remove_index(p->tab_coordonnees,i); 
  g_array_insert_val(p->tab_coordonnees,i,c);
}
/*Precondition : Plume initialisee, i <=taille utilisee du tableau de coordonnees*/
void SuppPointEncrage(Plume *p,unsigned int i)
{
  g_array_remove_index(p->tab_coordonnees,i);
}

/*Precondition : Plume initialisee
Postcondition : La Plume ne peut plus etre utilisee
la memoire alloue pour le tableau est supprimee*/
void SupprimerPlume(Plume *p)
{
  
  p->coorPl.x=0;
  p->coorPl.y=0;

  p->contour.r=0;
  p->contour.g=0;
  p->contour.b=0;

  p->fond.r=0;
  p->fond.g=0;
  p->fond.b=0;

  p->dimX=0;
  p->dimY=0;
  p->epaisseur_contour=0;

  g_array_free(p->tab_coordonnees,FALSE);
}

   @endcode

   @file Rectangle.c
   @brief Detail du code Rectangle.c
   @code

/* InitRectangle initialise dim (apr?s v?rification) de la structure Rectangle */
/*Precondition : Rectangle non initialisee
Postcondition : Rectangle initialisee*/
void InitRectangle(Rectangle * rec)
{
   rec->coordoRec.x=0;
   rec->coordoRec.y=0;
   rec->contour.r=0;
   rec->contour.g=0;
   rec->contour.b=0;
   rec->fond.r=0;
   rec->fond.g=0;
   rec->fond.b=0;
   rec->dimX=0;
   rec->dimY=0;
   rec->epaisseur_contour=0;
}
/*Precondition : Rectangle initialisee*/

void CreerRectangle(Rectangle * rec,double dimX, double dimY, double epaisseur_contour, Couleur fond, Couleur contour, Coordonnees c)
{
  assert(dimX>=0 && dimY>=0 && epaisseur_contour >=0);
  assert(c.x>=0 && c.y>=0);
  rec->coordoRec.x=c.x;
  rec->coordoRec.y=c.y;
  rec->contour.r=contour.r;
  rec->contour.g=contour.g;
  rec->contour.b=contour.b;
  rec->fond.r=fond.r;
  rec->fond.g=fond.g;
  rec->fond.b=fond.b;
  rec->dimX=dimX;
  rec->dimY=dimY;
  rec->epaisseur_contour=epaisseur_contour;

}

/*Precondition : Rectangle initialisee*/
void ModifierFondRectangle(Rectangle * rec,Couleur fond)
{
  rec-> fond.r=fond.r;
  rec-> fond.g=fond.g;
  rec-> fond.g=fond.b;

}

/*Precondition : Rectangle initialisee et la dimension est une valeur positive*/
void ModifierTailleRectangle(Rectangle * rec,double dimX, double dimY)
{
  assert(dimX>=0 && dimY>=0);
  assert(dimX!=dimY);
  rec->dimX=dimX;
  rec->dimX=dimX;
}

/*Precondition : Rectangle initialisee */
void ModifierContourRectangle(Rectangle * rec,double epaisseur_contour,Couleur contour)
{
  assert(epaisseur_contour>=0);
  rec->contour.r=contour.r;
  rec->contour.g=contour.g;
  rec->contour.b=contour.b;
  rec->epaisseur_contour=epaisseur_contour;
}

/*Precondition : Rectangle initialisee */
void ModifierCoordonneesRectangle(Rectangle * rec,Coordonnees c)
{
  assert(c.x>=0 && c.y>=0);
  rec->coordoRec.x=c.x;
  rec->coordoRec.y=c.y;
}
@endcode
*/
